LLM应用全流程开发课件

Appearance

使用Docker构建Elasticsearch本地搜索环境 ​

本章将详细介绍如何在本地使用Docker（及Docker Compose）构建和运行Elasticsearch环境，为大语言模型（LLM）提供高效的本地化搜索方案。我们将从环境准备、单节点部署到多节点集群，再到实际的数据操作和搜索应用，进行全面讲解。

一、环境准备 ​

1. 安装Docker与Docker Compose ​

请参考官方文档完成安装：

2. 创建Docker网络 ​

为保证Elasticsearch节点间通信，创建专用网络：

bash
docker network create elastic

此命令会生成名为elastic的自定义网络，用于后续容器互联。

二、使用官方脚本快速部署 ​

为了简化Elasticsearch和Kibana的本地部署过程，Elastic官方提供了start-local.sh脚本，能够自动完成配置和启动。

1. 脚本功能介绍 ​

start-local.sh是一个Shell脚本，可以帮助您：

  • 自动下载并运行最新版本的Elasticsearch和Kibana Docker容器
  • 生成随机密码并配置安全设置
  • 创建必要的API密钥
  • 支持单独部署Elasticsearch(-esonly参数)
  • 支持指定特定版本(-v参数)

2. 在Linux/macOS中运行 ​

bash
# 下载脚本
curl -O https://raw.githubusercontent.com/elastic/start-local/main/start-local.sh

# 添加执行权限
chmod +x start-local.sh

# 运行脚本
./start-local.sh

3. 在Windows中运行 ​

Windows用户可以通过以下几种方式运行该Shell脚本：

方法一：使用WSL (Windows Subsystem for Linux) ​

bash
# 安装WSL
# 以管理员身份打开PowerShell并运行：
wsl --install

# 重启电脑后完成安装
# 在WSL中运行脚本：
# 将脚本复制到WSL环境中
curl -O https://raw.githubusercontent.com/elastic/start-local/main/start-local.sh

# 添加执行权限
chmod +x start-local.sh

# 运行脚本
./start-local.sh

方法二：使用Git Bash ​

bash
# 安装Git for Windows，它包含Git Bash：
# 下载地址：https://git-scm.com/download/win

# 在Git Bash中运行脚本：
# 打开Git Bash
# 进入脚本所在目录
curl -O https://raw.githubusercontent.com/elastic/start-local/main/start-local.sh

# 运行
sh start-local.sh

方法三：使用Docker Desktop的集成终端 ​

如果您已安装Docker Desktop for Windows，也可以使用其集成的终端：

  1. 打开Docker Desktop
  2. 点击右上角的终端图标打开Docker终端
  3. 下载并运行脚本：
bash
curl -O https://raw.githubusercontent.com/elastic/start-local/main/start-local.sh
sh start-local.sh

4. 脚本执行后的操作 ​

脚本执行成功后，将：

  • 在当前目录创建elastic-start-local文件夹，包含所有配置文件
  • 自动启动Elasticsearch和Kibana容器
  • 显示登录信息，包括密码和API密钥

访问服务 ​

常用管理命令 ​

bash
# 停止服务
cd elastic-start-local
./stop.sh

# 重新启动服务
./start.sh

# 卸载服务
./uninstall.sh

5. 常见问题排查 ​

  • Docker未运行：确保Docker服务已启动
  • 端口冲突：检查9200和5601端口是否被占用
  • 内存不足：Docker Desktop至少需要分配4GB内存
  • Windows权限问题：确保WSL或Git Bash有足够权限操作Docker

使用此脚本可以大大简化本地开发环境的配置过程，特别适合快速启动并测试LLM的RAG应用场景。

三、单节点快速启动 ​

单节点模式适合本地开发和测试，是LLM本地搜索的最佳入门配置。

1. 拉取镜像 ​

bash
docker pull docker.elastic.co/elasticsearch/elasticsearch:8

💡 这里使用最新的Elasticsearch 8版本，您可以根据需要选择特定版本。

2. 启动容器 ​

bash
docker run -d \
  --name es-single \
  --network elastic \
  -p 9200:9200 -p 9300:9300 \
  -e "discovery.type=single-node" \
  -e "xpack.security.enabled=false" \
  -e "ES_JAVA_OPTS=-Xms512m -Xmx512m" \
  docker.elastic.co/elasticsearch/elasticsearch:8

参数说明：

  • discovery.type=single-node：禁用集群发现，强制单节点模式
  • xpack.security.enabled=false：简化本地开发，禁用安全认证
  • ES_JAVA_OPTS：设置JVM堆内存（本例为512MB，可根据机器配置调整）

3. 验证服务 ​

启动后通过以下命令验证Elasticsearch是否正常运行：

bash
curl http://localhost:9200/

若返回类似以下JSON信息，表示服务已成功启动：

json
{
  "name" : "es-single",
  "cluster_name" : "docker-cluster",
  "cluster_uuid" : "xyzAbCdEfG123",
  "version" : {
    "number" : "8.12.0",
    "build_flavor" : "default",
    "build_type" : "docker",
    "build_hash" : "abc123def456",
    "build_date" : "2023-02-10T12:34:56.789Z",
    "build_snapshot" : false,
    "lucene_version" : "9.8.0",
    "minimum_wire_compatibility_version" : "7.17.0",
    "minimum_index_compatibility_version" : "7.0.0"
  },
  "tagline" : "You Know, for Search"
}

四、使用Docker Compose部署集群 ​

对于需要更高可用性或性能的场景，推荐使用Docker Compose部署多节点集群。

1. 编写docker-compose.yml ​

创建docker-compose.yml文件，内容如下：

yaml
version: '3.8'
services:
  es01:
    image: docker.elastic.co/elasticsearch/elasticsearch:8
    container_name: es01
    networks:
      - elastic
    environment:
      - node.name=es01
      - cluster.name=es-cluster
      - discovery.seed_hosts=es02,es03
      - cluster.initial_master_nodes=es01,es02,es03
      - bootstrap.memory_lock=true
      - "ES_JAVA_OPTS=-Xms1g -Xmx1g"
      - xpack.security.enabled=false
    ulimits:
      memlock:
        soft: -1
        hard: -1
    volumes:
      - esdata01:/usr/share/elasticsearch/data
    ports:
      - 9200:9200

  es02:
    image: docker.elastic.co/elasticsearch/elasticsearch:8
    container_name: es02
    networks:
      - elastic
    environment:
      - node.name=es02
      - cluster.name=es-cluster
      - discovery.seed_hosts=es01,es03
      - cluster.initial_master_nodes=es01,es02,es03
      - bootstrap.memory_lock=true
      - "ES_JAVA_OPTS=-Xms1g -Xmx1g"
      - xpack.security.enabled=false
    ulimits:
      memlock:
        soft: -1
        hard: -1
    volumes:
      - esdata02:/usr/share/elasticsearch/data

  es03:
    image: docker.elastic.co/elasticsearch/elasticsearch:8
    container_name: es03
    networks:
      - elastic
    environment:
      - node.name=es03
      - cluster.name=es-cluster
      - discovery.seed_hosts=es01,es02
      - cluster.initial_master_nodes=es01,es02,es03
      - bootstrap.memory_lock=true
      - "ES_JAVA_OPTS=-Xms1g -Xmx1g"
      - xpack.security.enabled=false
    ulimits:
      memlock:
        soft: -1
        hard: -1
    volumes:
      - esdata03:/usr/share/elasticsearch/data

volumes:
  esdata01:
  esdata02:
  esdata03:

networks:
  elastic:
    external: true

配置说明：

  • 定义3个节点，实现基础集群功能
  • volumes用于数据持久化，防止重启丢失
  • ulimits.memlock与bootstrap.memory_lock共同锁定内存，避免交换到磁盘

2. 启动集群 ​

bash
docker-compose up -d

启动完成后，可通过以下命令查看集群健康状态：

bash
curl http://localhost:9200/_cluster/health?pretty

返回结果示例：

json
{
  "cluster_name" : "es-cluster",
  "status" : "green",
  "timed_out" : false,
  "number_of_nodes" : 3,
  "number_of_data_nodes" : 3,
  "active_primary_shards" : 1,
  "active_shards" : 2,
  "relocating_shards" : 0,
  "initializing_shards" : 0,
  "unassigned_shards" : 0,
  "delayed_unassigned_shards" : 0,
  "number_of_pending_tasks" : 0,
  "number_of_in_flight_fetch" : 0,
  "task_max_waiting_in_queue_millis" : 0,
  "active_shards_percent_as_number" : 100.0
}

五、高级配置 ​

1. 自定义elasticsearch.yml ​

若需更改网络绑定、集群名称等，可将本地配置文件挂载到容器：

yaml
volumes:
  - ./config/elasticsearch.yml:/usr/share/elasticsearch/config/elasticsearch.yml

配置文件示例：

yaml
# elasticsearch.yml
network.host: 0.0.0.0
http.port: 9200
discovery.seed_hosts: ["es01","es02","es03"]
cluster.initial_master_nodes: ["es01","es02","es03"]

2. 安装插件（以IK中文分词器为例） ​

2.1 下载IK分词器插件 ​

bash
docker run --rm \
  -v $(pwd)/plugins:/usr/share/elasticsearch/plugins \
  -e "ES_JAVA_OPTS=-Xms256m -Xmx256m" \
  docker.elastic.co/elasticsearch/elasticsearch:8 \
  bin/elasticsearch-plugin install https://github.com/medcl/elasticsearch-analysis-ik/releases/download/v8.12.0/elasticsearch-analysis-ik-8.12.0.zip

注意：请确保插件版本与Elasticsearch版本匹配

2.2 在docker-compose.yml中挂载插件 ​

yaml
volumes:
  - ./plugins:/usr/share/elasticsearch/plugins

3. 调整安全与访问设置 ​

3.1 禁用X-Pack安全（仅限本地开发） ​

yaml
environment:
  - xpack.security.enabled=false

3.2 开放跨域（便于接入前端可视化） ​

yaml
environment:
  - http.cors.enabled=true
  - http.cors.allow-origin=*

六、为LLM构建本地搜索引擎 ​

本节将介绍如何使用Elasticsearch为大语言模型提供本地化的搜索方案，包括索引创建、文档管理和查询示例。

1. 创建索引 ​

首先，创建一个适合文本检索的索引：

bash
curl -X PUT "localhost:9200/llm_documents" -H "Content-Type: application/json" -d'
{
  "settings": {
    "number_of_shards": 1,
    "number_of_replicas": 0,
    "analysis": {
      "analyzer": {
        "text_analyzer": {
          "type": "custom",
          "tokenizer": "standard",
          "filter": ["lowercase", "asciifolding"]
        }
      }
    }
  },
  "mappings": {
    "properties": {
      "title": {
        "type": "text",
        "analyzer": "text_analyzer"
      },
      "content": {
        "type": "text",
        "analyzer": "text_analyzer"
      },
      "embedding": {
        "type": "dense_vector",
        "dims": 384
      },
      "metadata": {
        "type": "object",
        "enabled": true
      },
      "timestamp": {
        "type": "date"
      }
    }
  }
}'

💡 Dense Vector：用于存储文本的向量表示，dims值应根据您使用的嵌入模型调整（例如，sentence-transformers模型通常为384或768维）。

2. 索引文档示例 ​

以下是向索引中添加文档的示例：

bash
curl -X POST "localhost:9200/llm_documents/_doc" -H "Content-Type: application/json" -d'
{
  "title": "Elasticsearch入门",
  "content": "Elasticsearch是一个分布式的RESTful搜索和分析引擎，能够解决越来越多的用例。作为Elastic Stack的核心，它集中存储您的数据，帮助您发现意料之中以及意料之外的情况。",
  "metadata": {
    "author": "Elastic",
    "category": "教程",
    "tags": ["搜索引擎", "分布式", "全文检索"]
  },
  "timestamp": "2023-04-01T12:00:00Z"
}'

批量导入多个文档：

bash
curl -X POST "localhost:9200/llm_documents/_bulk" -H "Content-Type: application/json" -d'
{"index":{}}
{"title":"向量检索基础","content":"向量检索是一种基于相似性的搜索方法，它通过计算查询向量与索引向量之间的距离来找到最相关的文档。","metadata":{"author":"AI研究员","category":"技术","tags":["向量检索","相似度搜索"]},"timestamp":"2023-04-02T10:30:00Z"}
{"index":{}}
{"title":"大语言模型应用","content":"大语言模型可以通过检索增强生成(RAG)技术，利用外部知识提高回答的准确性和相关性。Elasticsearch作为向量数据库可以存储和检索这些外部知识。","metadata":{"author":"LLM专家","category":"AI应用","tags":["LLM","RAG","知识库"]},"timestamp":"2023-04-03T16:45:00Z"}
'

3. 基础搜索查询 ​

3.1 全文搜索 ​

bash
curl -X GET "localhost:9200/llm_documents/_search" -H "Content-Type: application/json" -d'
{
  "query": {
    "multi_match": {
      "query": "大语言模型 知识库",
      "fields": ["title", "content"]
    }
  }
}'

3.2 精确短语匹配 ​

bash
curl -X GET "localhost:9200/llm_documents/_search" -H "Content-Type: application/json" -d'
{
  "query": {
    "match_phrase": {
      "content": "检索增强生成"
    }
  }
}'

3.3 复合条件查询 ​

bash
curl -X GET "localhost:9200/llm_documents/_search" -H "Content-Type: application/json" -d'
{
  "query": {
    "bool": {
      "must": [
        { "match": { "content": "elasticsearch" } }
      ],
      "filter": [
        { "term": { "metadata.category": "技术" } }
      ],
      "should": [
        { "match": { "content": "向量" } }
      ],
      "must_not": [
        { "match": { "content": "复杂" } }
      ]
    }
  }
}'

七、Elasticsearch实现RAG与向量搜索 ​

1. RAG(检索增强生成)概述 ​

RAG是一种结合了外部知识检索和语言模型生成能力的技术，可以有效解决LLM的以下挑战：

  • 领域知识不足：一般性LLM无法回答特定领域或组织内部的专业问题
  • 知识滞后：LLM的知识在训练后"冻结"，无法获取最新信息
  • 虚构现象(幻觉)：在不确定的情况下，LLM可能会生成看似合理但实际错误的内容
  • 训练成本高：完整训练或微调大模型需要大量资源和专业知识

RAG的工作原理 ​

RAG由三个核心组件组成：

  1. 数据库：包含相关信息的文档集合（如网页、文档等）
  2. 检索系统：从数据库中检索与问题相关的信息
  3. 生成模型：利用检索到的信息，生成准确的回答

Elasticsearch作为强大的搜索引擎和向量数据库，非常适合作为RAG系统的检索组件。

2. Elasticsearch向量搜索配置 ​

要使用Elasticsearch进行向量搜索，需要创建包含向量字段的索引：

bash
curl -X PUT "localhost:9200/rag_index" -H "Content-Type: application/json" -d'
{
  "settings": {
    "number_of_shards": 1,
    "number_of_replicas": 0
  },
  "mappings": {
    "properties": {
      "text": {
        "type": "text"
      },
      "text_embedding": {
        "type": "dense_vector",
        "dims": 384,
        "index": true,
        "similarity": "cosine"
      }
    }
  }
}'

这里定义了一个text_embedding字段，使用384维的密集向量表示，并启用了向量索引，使用余弦相似度进行向量比较。

3. 实现完整的RAG流程 ​

3.1 文档分块与向量化 ​

首先，我们需要将文档分割成适当大小的块，并为每个块生成向量嵌入：

python
import requests
import json
from sentence_transformers import SentenceTransformer

# 1. 加载文档并分块
def chunk_document(document, chunk_size=200, overlap=50):
    words = document.split()
    chunks = []
    for i in range(0, len(words), chunk_size - overlap):
        chunk = ' '.join(words[i:i + chunk_size])
        chunks.append(chunk)
    return chunks

# 2. 生成嵌入向量
model = SentenceTransformer('all-MiniLM-L6-v2')  # 384维向量模型

def generate_embeddings(chunks):
    return model.encode(chunks).tolist()

# 3. 索引到Elasticsearch
def index_to_elasticsearch(chunks, embeddings):
    for i, (chunk, embedding) in enumerate(zip(chunks, embeddings)):
        document = {
            "text": chunk,
            "text_embedding": embedding
        }
        
        response = requests.post(
            "http://localhost:9200/rag_index/_doc",
            headers={"Content-Type": "application/json"},
            data=json.dumps(document)
        )
        print(f"Indexed chunk {i+1}: {response.status_code}")

# 示例使用
document = """
Elasticsearch是一个分布式的RESTful搜索和分析引擎，能够解决越来越多的用例。
作为Elastic Stack的核心，它集中存储您的数据，帮助您发现意料之中以及意料之外的情况。
Elasticsearch可用于全文搜索、结构化搜索、分析以及这三个功能的组合。
"""

chunks = chunk_document(document)
embeddings = generate_embeddings(chunks)
index_to_elasticsearch(chunks, embeddings)

3.2 向量检索查询 ​

当用户提出问题时，将问题转换为向量，然后在Elasticsearch中进行向量搜索：

python
def semantic_search(query, top_k=3):
    # 生成查询向量
    query_embedding = model.encode([query])[0].tolist()
    
    # 向量搜索
    search_query = {
        "size": top_k,
        "query": {
            "script_score": {
                "query": {"match_all": {}},
                "script": {
                    "source": "cosineSimilarity(params.query_vector, 'text_embedding') + 1.0",
                    "params": {"query_vector": query_embedding}
                }
            }
        }
    }
    
    response = requests.post(
        "http://localhost:9200/rag_index/_search",
        headers={"Content-Type": "application/json"},
        data=json.dumps(search_query)
    )
    
    results = []
    hits = response.json()["hits"]["hits"]
    for hit in hits:
        results.append({
            "text": hit["_source"]["text"],
            "score": hit["_score"]
        })
    
    return results

3.3 结合LLM生成回答 ​

最后，将检索到的相关文本作为上下文提供给LLM，生成针对用户问题的回答：

python
from openai import OpenAI

client = OpenAI(api_key="your-api-key")

def generate_answer(query, context_texts):
    # 构建提示
    context = "\n".join(context_texts)
    prompt = f"""根据以下信息回答问题：

信息:
{context}

问题: {query}

请只基于提供的信息回答。如果信息中没有足够的内容来回答问题，请说明"我没有足够的信息来回答这个问题"。
"""

    response = client.chat.completions.create(
        model="gpt-3.5-turbo",
        messages=[
            {"role": "system", "content": "你是一位专业的AI助手，根据提供的信息回答问题。"},
            {"role": "user", "content": prompt}
        ],
        max_tokens=500
    )
    
    return response.choices[0].message.content

# 完整RAG流程
def rag_pipeline(query):
    # 1. 检索相关文档
    search_results = semantic_search(query)
    context_texts = [result["text"] for result in search_results]
    
    # 2. 生成回答
    answer = generate_answer(query, context_texts)
    
    return {
        "query": query,
        "context": context_texts,
        "answer": answer
    }

# 示例
result = rag_pipeline("Elasticsearch可以用来做什么？")
print(f"答案: {result['answer']}")

4. 基于Elasticsearch的向量搜索优化 ​

4.1 Better Binary Quantization (BBQ) ​

Elasticsearch提供了BBQ技术，可以显著减少向量存储空间并提高检索性能：

bash
curl -X PUT "localhost:9200/optimized_rag_index" -H "Content-Type: application/json" -d'
{
  "settings": {
    "number_of_shards": 1,
    "number_of_replicas": 0
  },
  "mappings": {
    "properties": {
      "text": {
        "type": "text"
      },
      "text_embedding": {
        "type": "dense_vector",
        "dims": 384,
        "index": true,
        "similarity": "cosine",
        "index_options": {
          "type": "hnsw",
          "m": 16,
          "ef_construction": 100
        },
        "element_type": "byte",
        "model_id": "bbq_model"
      }
    }
  }
}'

这里使用了element_type: "byte"和model_id参数启用BBQ，可以将浮点向量量化为字节表示，大幅减少存储空间。

4.2 HNSW图优化 ​

为大规模向量集合优化HNSW图参数：

bash
curl -X PUT "localhost:9200/large_scale_rag_index" -H "Content-Type: application/json" -d'
{
  "settings": {
    "number_of_shards": 5,
    "number_of_replicas": 1
  },
  "mappings": {
    "properties": {
      "text": { "type": "text" },
      "text_embedding": {
        "type": "dense_vector",
        "dims": 384,
        "index": true,
        "similarity": "cosine",
        "index_options": {
          "type": "hnsw",
          "m": 32,
          "ef_construction": 200,
          "ef_search": 100
        }
      }
    }
  }
}'

参数说明：

  • m: 每个节点的最大连接数，较大的值提供更好的精度但需要更多内存
  • ef_construction: 构建时探索的节点数，较大的值提供更好的精度但构建速度更慢
  • ef_search: 搜索时探索的节点数，较大的值提供更好的精度但搜索速度更慢

4.3 混合检索策略 ​

结合关键词搜索与向量搜索的优势：

bash
curl -X GET "localhost:9200/rag_index/_search" -H "Content-Type: application/json" -d'
{
  "query": {
    "bool": {
      "should": [
        {
          "match": {
            "text": {
              "query": "Elasticsearch搜索功能",
              "boost": 0.3
            }
          }
        },
        {
          "script_score": {
            "query": {"match_all": {}},
            "script": {
              "source": "cosineSimilarity(params.query_vector, \"text_embedding\") + 1.0",
              "params": {
                "query_vector": [0.1, 0.2, ... 0.3]
              }
            },
            "boost": 0.7
          }
        }
      ]
    }
  }
}'

这种混合策略结合了BM25算法（精确文本匹配）和向量相似度（语义匹配），通过boost参数调整二者权重。

5. 语义文本字段 (Semantic Text) ​

Elasticsearch最新版本提供了semantic_text字段类型，简化RAG实现：

bash
curl -X PUT "localhost:9200/semantic_rag_index" -H "Content-Type: application/json" -d'
{
  "mappings": {
    "properties": {
      "content": {
        "type": "semantic_text",
        "embeddings": true,
        "model_id": ".elser_model_2",
        "analyzer": "default"
      }
    }
  }
}'

使用semantic_text字段后，搜索变得非常简单：

bash
curl -X GET "localhost:9200/semantic_rag_index/_search" -H "Content-Type: application/json" -d'
{
  "query": {
    "semantic": {
      "content": {
        "query": "大语言模型如何使用外部知识？",
        "model_id": ".elser_model_2",
        "model_text": "semantic_search"
      }
    }
  }
}'

semantic_text字段自动处理文本分块、嵌入生成和索引，大大简化了RAG实现流程。

七、运行与管理 ​

常用命令 ​

查看容器状态 ​

bash
docker ps

查看日志 ​

bash
docker-compose logs -f

停止并移除 ​

bash
docker-compose down

常见故障排除 ​

  • 端口冲突：检查是否已有服务占用9200/9300端口

    bash
    lsof -i :9200
# 或
netstat -ano | grep 9200

  • 内存不足：根据宿主机实际内存，调整ES_JAVA_OPTS（-Xms与-Xmx）

    bash
    # 检查ES日志是否有OOM错误
docker logs es-single | grep "OutOfMemoryError"

  • 挂载权限问题：确保宿主机目录对Docker进程可读写

    bash
    chmod -R 777 ./data

  • 集群未正常形成：检查节点发现配置和网络连通性

    bash
    # 检查集群状态
curl http://localhost:9200/_cluster/health?pretty

# 检查节点列表
curl http://localhost:9200/_cat/nodes?v

八、推荐阅读与官方资源 ​

本章介绍的方法可帮助您在本地快速搭建Elasticsearch环境，为大语言模型提供高效的本地化搜索支持，适合RAG（检索增强生成）等应用场景。